1 /*
2  Copyright (C) 2010-2014 Kristian Duske
3 
4  This file is part of TrenchBroom.
5 
6  TrenchBroom is free software: you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation, either version 3 of the License, or
9  (at your option) any later version.
10 
11  TrenchBroom is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with TrenchBroom. If not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #include "BrushFaceAttributes.h"
21 #include "Assets/Texture.h"
22 
23 namespace TrenchBroom {
24     namespace Model {
BrushFaceAttributes(const String & textureName)25         BrushFaceAttributes::BrushFaceAttributes(const String& textureName) :
26         m_textureName(textureName),
27         m_texture(NULL),
28         m_offset(Vec2f::Null),
29         m_scale(Vec2f(1.0f, 1.0f)),
30         m_rotation(0.0f),
31         m_surfaceContents(0),
32         m_surfaceFlags(0),
33         m_surfaceValue(0.0f) {}
34 
BrushFaceAttributes(const BrushFaceAttributes & other)35         BrushFaceAttributes::BrushFaceAttributes(const BrushFaceAttributes& other) :
36         m_textureName(other.m_textureName),
37         m_texture(other.m_texture),
38         m_offset(other.m_offset),
39         m_scale(other.m_scale),
40         m_rotation(other.m_rotation),
41         m_surfaceContents(other.m_surfaceContents),
42         m_surfaceFlags(other.m_surfaceFlags),
43         m_surfaceValue(other.m_surfaceValue) {
44             if (m_texture != NULL)
45                 m_texture->incUsageCount();
46         }
47 
~BrushFaceAttributes()48         BrushFaceAttributes::~BrushFaceAttributes() {
49             if (m_texture != NULL)
50                 m_texture->decUsageCount();
51         }
52 
operator =(BrushFaceAttributes other)53         BrushFaceAttributes& BrushFaceAttributes::operator=(BrushFaceAttributes other) {
54             using std::swap;
55             swap(*this, other);
56             return *this;
57         }
58 
swap(BrushFaceAttributes & lhs,BrushFaceAttributes & rhs)59         void swap(BrushFaceAttributes& lhs, BrushFaceAttributes& rhs) {
60             using std::swap;
61             swap(lhs.m_textureName, rhs.m_textureName);
62             swap(lhs.m_texture, rhs.m_texture);
63             swap(lhs.m_offset, rhs.m_offset);
64             swap(lhs.m_scale, rhs.m_scale);
65             swap(lhs.m_rotation, rhs.m_rotation);
66             swap(lhs.m_surfaceContents, rhs.m_surfaceContents);
67             swap(lhs.m_surfaceFlags, rhs.m_surfaceFlags);
68             swap(lhs.m_surfaceValue, rhs.m_surfaceValue);
69         }
70 
takeSnapshot() const71         BrushFaceAttributes BrushFaceAttributes::takeSnapshot() const {
72             BrushFaceAttributes result(m_textureName);
73             result.m_offset = m_offset;
74             result.m_scale = m_scale;
75             result.m_rotation = m_rotation;
76             result.m_surfaceContents = m_surfaceContents;
77             result.m_surfaceFlags = m_surfaceFlags;
78             result.m_surfaceValue = m_surfaceValue;
79             return result;
80         }
81 
textureName() const82         const String& BrushFaceAttributes::textureName() const {
83             return m_textureName;
84         }
85 
texture() const86         Assets::Texture* BrushFaceAttributes::texture() const {
87             return m_texture;
88         }
89 
textureSize() const90         Vec2f BrushFaceAttributes::textureSize() const {
91             if (m_texture == NULL)
92                 return Vec2f::One;
93             const float w = m_texture->width()  == 0 ? 1.0f : static_cast<float>(m_texture->width());
94             const float h = m_texture->height() == 0 ? 1.0f : static_cast<float>(m_texture->height());
95             return Vec2f(w, h);
96         }
97 
offset() const98         const Vec2f& BrushFaceAttributes::offset() const {
99             return m_offset;
100         }
101 
xOffset() const102         float BrushFaceAttributes::xOffset() const {
103             return m_offset.x();
104         }
105 
yOffset() const106         float BrushFaceAttributes::yOffset() const {
107             return m_offset.y();
108         }
109 
modOffset(const Vec2f & offset) const110         Vec2f BrushFaceAttributes::modOffset(const Vec2f& offset) const {
111             return offset - offset.roundDownToMultiple(textureSize());
112         }
113 
scale() const114         const Vec2f& BrushFaceAttributes::scale() const {
115             return m_scale;
116         }
117 
xScale() const118         float BrushFaceAttributes::xScale() const {
119             return m_scale.x();
120         }
121 
yScale() const122         float BrushFaceAttributes::yScale() const {
123             return m_scale.y();
124         }
125 
rotation() const126         float BrushFaceAttributes::rotation() const {
127             return m_rotation;
128         }
129 
surfaceContents() const130         int BrushFaceAttributes::surfaceContents() const {
131             return m_surfaceContents;
132         }
133 
surfaceFlags() const134         int BrushFaceAttributes::surfaceFlags() const {
135             return m_surfaceFlags;
136         }
137 
surfaceValue() const138         float BrushFaceAttributes::surfaceValue() const {
139             return m_surfaceValue;
140         }
141 
setTexture(Assets::Texture * texture)142         void BrushFaceAttributes::setTexture(Assets::Texture* texture) {
143             if (m_texture != NULL)
144                 m_texture->decUsageCount();
145             m_texture = texture;
146             if (m_texture != NULL) {
147                 m_texture->incUsageCount();
148                 m_textureName = m_texture->name();
149             }
150         }
151 
setOffset(const Vec2f & offset)152         void BrushFaceAttributes::setOffset(const Vec2f& offset) {
153             m_offset = offset;
154         }
155 
setXOffset(const float xOffset)156         void BrushFaceAttributes::setXOffset(const float xOffset) {
157             m_offset[0] = xOffset;
158         }
159 
setYOffset(const float yOffset)160         void BrushFaceAttributes::setYOffset(const float yOffset) {
161             m_offset[1] = yOffset;
162         }
163 
setScale(const Vec2f & scale)164         void BrushFaceAttributes::setScale(const Vec2f& scale) {
165             m_scale = scale;
166         }
167 
setXScale(const float xScale)168         void BrushFaceAttributes::setXScale(const float xScale) {
169             m_scale[0] = xScale;
170         }
171 
setYScale(const float yScale)172         void BrushFaceAttributes::setYScale(const float yScale) {
173             m_scale[1] = yScale;
174         }
175 
setRotation(const float rotation)176         void BrushFaceAttributes::setRotation(const float rotation) {
177             m_rotation = rotation;
178         }
179 
setSurfaceContents(const int surfaceContents)180         void BrushFaceAttributes::setSurfaceContents(const int surfaceContents) {
181             m_surfaceContents = surfaceContents;
182         }
183 
setSurfaceFlags(const int surfaceFlags)184         void BrushFaceAttributes::setSurfaceFlags(const int surfaceFlags) {
185             m_surfaceFlags = surfaceFlags;
186         }
187 
setSurfaceValue(const float surfaceValue)188         void BrushFaceAttributes::setSurfaceValue(const float surfaceValue) {
189             m_surfaceValue = surfaceValue;
190         }
191     }
192 }
193